package com.jhhc.Liunx.Util;
import java.io.*;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.*;

import org.apache.commons.io.FileSystemUtils;

public class OSUtils {

    /**
     * 功能：可用磁盘
     * */
    public static int disk() {
        try {
            long total = FileSystemUtils.freeSpaceKb("/home");
            double disk = (double) total / 1024 / 1024;
            return (int) disk;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 功能：获取Linux系统cpu使用率
     * */
    public static int cpuUsage() {
        try {
            Map<?, ?> map1 = OSUtils.cpuinfo();
            Thread.sleep( 1000);
            Map<?, ?> map2 = OSUtils.cpuinfo();

            long user1 = Long.parseLong(map1.get("user").toString());
            long nice1 = Long.parseLong(map1.get("nice").toString());
            long system1 = Long.parseLong(map1.get("system").toString());
            long idle1 = Long.parseLong(map1.get("idle").toString());

            long user2 = Long.parseLong(map2.get("user").toString());
            long nice2 = Long.parseLong(map2.get("nice").toString());
            long system2 = Long.parseLong(map2.get("system").toString());
            long idle2 = Long.parseLong(map2.get("idle").toString());

            long total1 = user1 + system1 + nice1;
            long total2 = user2 + system2 + nice2;
            float total = total2 - total1;

            long totalIdle1 = user1 + nice1 + system1 + idle1;
            long totalIdle2 = user2 + nice2 + system2 + idle2;
            float totalidle = totalIdle2 - totalIdle1;

            float cpusage = (total / totalidle) * 100;
            return (int) cpusage;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * 功能：CPU使用信息
     * */
    public static Map<?, ?> cpuinfo() {
        InputStreamReader inputs = null;
        BufferedReader buffer = null;
        Map<String, Object> map = new HashMap<String, Object>();
        try {
            inputs = new InputStreamReader(new FileInputStream("/proc/stat"));
            buffer = new BufferedReader(inputs);
            String line = "";
            while (true) {
                line = buffer.readLine();
                if (line == null) {
                    break;
                }
                if (line.startsWith("cpu")) {
                    StringTokenizer tokenizer = new StringTokenizer(line);
                    List<String> temp = new ArrayList<String>();
                    while (tokenizer.hasMoreElements()) {
                        String value = tokenizer.nextToken();
                        temp.add(value);
                    }
                    map.put("user", temp.get(1));
                    map.put("nice", temp.get(2));
                    map.put("system", temp.get(3));
                    map.put("idle", temp.get(4));
                    map.put("iowait", temp.get(5));
                    map.put("irq", temp.get(6));
                    map.put("softirq", temp.get(7));
                    map.put("stealstolen", temp.get(8));
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                buffer.close();
                inputs.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return map;
    }

    /**
     * 功能：内存使用率
     * */
    public static int memoryUsage() {
        Map<String, Object> map = new HashMap<String, Object>();
        InputStreamReader inputs = null;
        BufferedReader buffer = null;
        try {
            inputs = new InputStreamReader(new FileInputStream("/proc/meminfo"));
            buffer = new BufferedReader(inputs);
            String line = "";
            while (true) {
                line = buffer.readLine();
                if (line == null)
                    break;
                int beginIndex = 0;
                int endIndex = line.indexOf(":");
                if (endIndex != -1) {
                    String key = line.substring(beginIndex, endIndex);
                    beginIndex = endIndex + 1;
                    endIndex = line.length();
                    String memory = line.substring(beginIndex, endIndex);
                    String value = memory.replace("kB", "").trim();
                    map.put(key, value);
                }
            }

            long memTotal = Long.parseLong(map.get("MemTotal").toString());
            long memFree = Long.parseLong(map.get("MemFree").toString());
            long memused = memTotal - memFree;
            long buffers = Long.parseLong(map.get("Buffers").toString());
            long cached = Long.parseLong(map.get("Cached").toString());

            double usage = (double) (memused - buffers - cached) / memTotal * 100;
            return (int) usage;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                buffer.close();
                inputs.close();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return 0;
    }
    /**
     * 功能：内存大小
     * */
    public static double getMemSize() {
        Double totalMem = 0.0;
        Process pro = null;
        Runtime r = Runtime.getRuntime();
        try {
            String command = "cat /proc/meminfo";
            pro = r.exec(command);
            BufferedReader in = new BufferedReader(new InputStreamReader(pro.getInputStream()));
            String line = null;
            int count = 0;
            while((line=in.readLine()) != null){
                String[] memInfo = line.split("\\s+");
                if(memInfo[0].startsWith("MemTotal")){
                    // totalMem = Long.parseLong(memInfo[1]);
                    totalMem = Double.valueOf(memInfo[1])/1000000;
                }
                if(++count == 2){
                    break;
                }
            }
            in.close();
            pro.destroy();
        } catch (IOException e) {
            StringWriter sw = new StringWriter();
            e.printStackTrace(new PrintWriter(sw));

        }
        return totalMem;


    }
    /**
     * 功能：获取ip
     * */

    public static String getInet4Address() {
        Enumeration<NetworkInterface> nis;
        String ip = null;
        try {
            nis = NetworkInterface.getNetworkInterfaces();
            for (; nis.hasMoreElements();) {
                NetworkInterface ni = nis.nextElement();
                Enumeration<InetAddress> ias = ni.getInetAddresses();
                for (; ias.hasMoreElements();) {
                    InetAddress ia = ias.nextElement();
                    //ia instanceof Inet6Address && !ia.equals("")
                    if (ia instanceof Inet4Address && !ia.getHostAddress().equals("127.0.0.1")) {
                        ip = ia.getHostAddress();
                    }
                }
            }
        } catch (SocketException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return ip;
    }

    /**
     * 获取磁盘空间大小
     * @return
     * @throws Exception
     */
    public static double getDeskUsage() throws Exception {
        double totalHD = 0;

        double usedHD = 0;

        Runtime rt = Runtime.getRuntime();

        Process p = rt.exec("df -hl /home");//df -hl 查看硬盘空间

        BufferedReader in = null;

        try {
            in = new BufferedReader(new InputStreamReader(p.getInputStream()));

            String str = null;

            String[] strArray = null;

            while ((str = in.readLine()) != null) {
                int m = 0;

                strArray = str.split(" ");

                for (String tmp : strArray) {
                    if (tmp.trim().length() == 0)

                        continue;

                    ++m;

                    System.out.println("----tmp----" + tmp);

                    if (tmp.indexOf("G") != -1) {
                        if (m == 2) {
                            System.out.println("---G----" + tmp);

                            if (!tmp.equals("") && !tmp.equals("0"))

                                totalHD += Double.parseDouble(tmp

                                        .substring(0, tmp.length() - 1)) * 1024;

                        }

                        if (m == 3) {
                            System.out.println("---G----" + tmp);

                            if (!tmp.equals("none") && !tmp.equals("0"))

                                usedHD += Double.parseDouble(tmp.substring(

                                        0, tmp.length() - 1)) * 1024;

                        }

                    }

                    if (tmp.indexOf("M") != -1) {
                        if (m == 2) {
                            System.out.println("---M---" + tmp);

                            if (!tmp.equals("") && !tmp.equals("0"))

                                totalHD += Double.parseDouble(tmp

                                        .substring(0, tmp.length() - 1));

                        }

                        if (m == 3) {
                            System.out.println("---M---" + tmp);

                            if (!tmp.equals("none") && !tmp.equals("0"))

                                usedHD += Double.parseDouble(tmp.substring(

                                        0, tmp.length() - 1));

                            System.out.println("----3----" + usedHD);

                        }

                    }

                }

            }

        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            in.close();

        }

//上面写在userd和total写反了，懒得改了，就反着用了

        System.out.println("----totalHD----" + usedHD);

        System.out.println("----usedHD----" + totalHD);

        return ( usedHD/totalHD ) * 100;

    }
}